// 右键菜单测试
console.log('background.js 已加载');

// 检查URL是否匹配模式
function matchUrlPattern(url, pattern) {
  try {
    // 解析当前URL
    const currentUrlObj = new URL(url);
    
    // 处理模式URL
    let patternUrl = pattern;
    // 如果没有协议前缀，添加http://
    if (!pattern.startsWith('http://') && !pattern.startsWith('https://')) {
      patternUrl = 'http://' + pattern;
    }
    
    // 解析模式URL
    const patternUrlObj = new URL(patternUrl);
    
    // 比较主机名和端口
    const hostnameMatch = currentUrlObj.hostname === patternUrlObj.hostname;
    const portMatch = currentUrlObj.port === patternUrlObj.port || 
                     (currentUrlObj.port === '' && patternUrlObj.port === '') ||
                     (currentUrlObj.port === '80' && patternUrlObj.port === '') ||
                     (currentUrlObj.port === '443' && patternUrlObj.port === '');
    
    console.log('URL匹配详情:', {
      currentUrl: url,
      pattern: pattern,
      currentHostname: currentUrlObj.hostname,
      patternHostname: patternUrlObj.hostname,
      currentPort: currentUrlObj.port,
      patternPort: patternUrlObj.port,
      hostnameMatch,
      portMatch
    });
    
    return hostnameMatch && portMatch;
  } catch (error) {
    console.error('URL匹配错误:', error);
    return false;
  }
}

// 安装时创建初始菜单
chrome.runtime.onInstalled.addListener(function() {
  console.log('插件已安装或更新');
  
  // 清除所有现有菜单
  chrome.contextMenus.removeAll(function() {
    console.log('已清除所有现有菜单');
    
    // 创建主菜单
    chrome.contextMenus.create({
      id: 'mainMenu',
      title: '按键精灵',
      contexts: ['all']
    });
    
    // 创建基础子菜单项
    chrome.contextMenus.create({
      id: 'translatePage',
      parentId: 'mainMenu',
      title: '翻译页面',
      contexts: ['all']
    });
    
    chrome.contextMenus.create({
      id: 'summarizePage',
      parentId: 'mainMenu',
      title: '总结页面',
      contexts: ['all']
    });
    
    chrome.contextMenus.create({
      id: 'translateAndSummarize',
      parentId: 'mainMenu',
      title: '翻译并总结',
      contexts: ['all']
    });
    
    console.log('已创建基础菜单项');
  });
});

// 获取匹配的按钮配置
async function getMatchingButtons(url) {
  try {
    // 从存储中获取URL模式配置
    const result = await chrome.storage.sync.get(['urlPatterns']);
    const patterns = result.urlPatterns || [];
    
    // 过滤出匹配当前URL的配置
    return patterns.filter(p => {
      // 确保pattern存在且非空
      if (!p.pattern || p.pattern.trim() === '') {
        return false;
      }
      return matchUrlPattern(url, p.pattern);
    });
  } catch (error) {
    console.error('获取匹配按钮时出错:', error);
    return [];
  }
}

// 更新右键菜单
async function updateContextMenu(tab) {
  try {
    if (!tab || !tab.url || !tab.url.startsWith('http')) {
      return;
    }
    
    // 获取匹配当前URL的按钮
    const matchingButtons = await getMatchingButtons(tab.url);
    
    // 删除现有菜单项
    chrome.contextMenus.removeAll(function() {
      // 重新创建主菜单
      chrome.contextMenus.create({
        id: 'mainMenu',
        title: '按键精灵',
        contexts: ['all']
      });
      
      // 创建基础子菜单项
      chrome.contextMenus.create({
        id: 'translatePage',
        parentId: 'mainMenu',
        title: '翻译页面',
        contexts: ['all']
      });
      
      chrome.contextMenus.create({
        id: 'summarizePage',
        parentId: 'mainMenu',
        title: '总结页面',
        contexts: ['all']
      });
      
      chrome.contextMenus.create({
        id: 'translateAndSummarize',
        parentId: 'mainMenu',
        title: '翻译并总结',
        contexts: ['all']
      });
      
      // 如果有分隔符，创建一个分隔符
      if (matchingButtons.length > 0) {
        chrome.contextMenus.create({
          id: 'separator',
          parentId: 'mainMenu',
          type: 'separator',
          contexts: ['all']
        });
      }
      
      // 创建匹配的自定义按钮菜单项
      matchingButtons.forEach((button, index) => {
        chrome.contextMenus.create({
          id: 'custom_' + index,
          parentId: 'mainMenu',
          title: button.buttonName,
          contexts: ['all']
        });
      });
    });
  } catch (error) {
    console.error('更新右键菜单失败:', error);
  }
}

// 监听标签页更新事件
chrome.tabs.onUpdated.addListener(function(tabId, changeInfo, tab) {
  if (changeInfo.status === 'complete') {
    console.log('标签页更新完成:', tab.url);
    updateContextMenu(tab);
  }
});

// 监听标签页激活事件
chrome.tabs.onActivated.addListener(function(activeInfo) {
  chrome.tabs.get(activeInfo.tabId, function(tab) {
    console.log('标签页激活:', tab.url);
    updateContextMenu(tab);
  });
});

// 添加菜单点击调试和日志
chrome.contextMenus.onClicked.addListener(function(info, tab) {
    console.log('菜单点击事件触发:', info.menuItemId);
    console.log('点击事件信息:', info);
    console.log('标签页信息:', tab);
    
    // 处理菜单点击
    if (info.menuItemId === 'translatePage') {
        sendMessageToTab(tab.id, { action: 'translatePage' });
    } else if (info.menuItemId === 'summarizePage') {
        sendMessageToTab(tab.id, { action: 'summarizePage' });
    } else if (info.menuItemId === 'translateAndSummarize') {
        sendMessageToTab(tab.id, { action: 'summarizeAndTranslate' });
    } else if (info.menuItemId.startsWith('custom_')) {
        handleCustomButton(info.menuItemId, tab);
    } else {
        console.warn('未知的菜单项ID:', info.menuItemId);
    }
});

// 向标签页发送消息的辅助函数
function sendMessageToTab(tabId, message) {
    console.log('准备向标签页发送消息:', tabId, message);
    
    // 生成唯一请求ID
    message.requestId = Date.now() + '-' + Math.random().toString(36).substr(2, 9);
    
    try {
        // 检查标签页是否存在
        chrome.tabs.get(tabId, function(tab) {
            if (chrome.runtime.lastError) {
                console.error('获取标签页失败:', chrome.runtime.lastError);
                return;
            }
            
            console.log('标签页存在，尝试注入content.js...');
            
            // 注入content.js确保其已加载
            chrome.scripting.executeScript({
                target: { tabId: tabId },
                files: ['content.js']
            }).then(() => {
                console.log('content.js注入成功，发送消息中...');
                chrome.tabs.sendMessage(tabId, message, function(response) {
                    if (chrome.runtime.lastError) {
                        console.error('向标签页发送消息失败:', chrome.runtime.lastError);
                    } else {
                        console.log('消息发送成功，响应:', response);
                    }
                });
            }).catch(error => {
                console.error('注入content.js失败:', error);
                // 尝试直接发送消息
                console.log('尝试直接发送消息...');
                chrome.tabs.sendMessage(tabId, message, function(response) {
                    if (chrome.runtime.lastError) {
                        console.error('直接发送消息失败:', chrome.runtime.lastError);
                    } else {
                        console.log('直接发送消息成功，响应:', response);
                    }
                });
            });
        });
    } catch (error) {
        console.error('发送消息过程中出错:', error);
    }
}

// 添加获取所有cookie的函数（包括HTTPOnly）
function getAllCookies(tab) {
  return new Promise((resolve, reject) => {
    try {
      // 解析url获取domain
      let urlObj;
      try {
        urlObj = new URL(tab.url);
      } catch (e) {
        console.error('解析URL失败:', e);
        reject(new Error('无效的URL'));
        return;
      }
      
      const domain = urlObj.hostname;
      console.log('获取域名的cookie:', domain);
      
      // 使用chrome.cookies API获取全部cookie（包括HTTPOnly）
      chrome.cookies.getAll({ domain: domain }, cookies => {
        if (chrome.runtime.lastError) {
          console.error('获取cookie失败:', chrome.runtime.lastError);
          reject(chrome.runtime.lastError);
          return;
        }
        
        console.log(`获取到${cookies.length}个cookie（包括HTTPOnly）`);
        resolve(cookies);
      });
    } catch (error) {
      console.error('获取cookie过程中出错:', error);
      reject(error);
    }
  });
}

// 处理自定义按钮点击
function handleCustomButton(menuItemId, tab) {
  try {
    const index = parseInt(menuItemId.split('_')[1]);
    console.log('处理自定义按钮点击, 索引:', index, '标签页:', tab.id);
    
    // 获取匹配的按钮配置
    getMatchingButtons(tab.url).then(matchingButtons => {
      if (index >= 0 && index < matchingButtons.length) {
        const buttonConfig = matchingButtons[index];
        
        // 生成唯一请求ID防止重复处理
        const requestId = `${tab.id}-${Date.now()}`;
        
        // 检查请求历史，防止重复发送（使用全局变量而非window）
        if (typeof _buttonClickHistory === 'undefined') {
          globalThis._buttonClickHistory = {};
        }
        
        // 如果5秒内已经点击过这个按钮，则忽略
        const buttonKey = `${tab.id}-${index}`;
        const now = Date.now();
        if (_buttonClickHistory[buttonKey] && 
            now - _buttonClickHistory[buttonKey] < 5000) {
          console.log('短时间内重复点击，忽略:', buttonKey);
          return;
        }
        
        // 记录点击时间
        _buttonClickHistory[buttonKey] = now;
        
        // 5秒后自动清除记录，允许再次点击
        setTimeout(() => {
          if (_buttonClickHistory[buttonKey]) {
            delete _buttonClickHistory[buttonKey];
          }
        }, 5000);
        
        console.log('发送消息到content script, 请求ID:', requestId);
        
        // 首先获取所有cookie
        if (buttonConfig.contentType === 'cookies') {
          console.log('需要获取cookie，包括HTTPOnly');
          
          // 获取包括HTTPOnly的全部cookie
          getAllCookies(tab).then(allCookies => {
            // 添加cookie到配置
            const configWithCookies = {
              ...buttonConfig,
              allCookies: allCookies
            };
            
            // 发送消息到content script
            chrome.tabs.sendMessage(tab.id, {
              action: 'sendPageData',
              config: configWithCookies,
              requestId: requestId
            }, response => {
              if (chrome.runtime.lastError) {
                console.error('发送消息失败:', chrome.runtime.lastError);
              } else {
                console.log('消息发送成功，响应:', response);
              }
            });
          }).catch(error => {
            console.error('获取cookie失败:', error);
            // 即使获取HTTPOnly cookie失败，仍然发送消息
            chrome.tabs.sendMessage(tab.id, {
              action: 'sendPageData',
              config: buttonConfig,
              requestId: requestId
            });
          });
        } else {
          // 不需要cookie，直接发送消息
          chrome.tabs.sendMessage(tab.id, {
            action: 'sendPageData',
            config: buttonConfig,
            requestId: requestId
          }, response => {
            if (chrome.runtime.lastError) {
              console.error('发送消息失败:', chrome.runtime.lastError);
            } else {
              console.log('消息发送成功，响应:', response);
            }
          });
        }
      } else {
        console.error('未找到匹配的按钮配置，索引:', index);
      }
    }).catch(error => {
      console.error('获取匹配按钮时出错:', error);
    });
  } catch (error) {
    console.error('处理按钮点击时出错:', error);
  }
}

// 修改checkShortcut函数
async function checkShortcut(shortcut) {
    try {
        console.log('检查快捷键:', shortcut);
        
        // 获取URL模式配置
        const result = await chrome.storage.sync.get(['urlPatterns']);
        const patterns = result.urlPatterns || [];
        
        console.log('获取到urlPatterns配置:', patterns);
        
        // 将输入的快捷键转换为小写进行比较
        const normalizedShortcut = shortcut.toLowerCase();
        
        // 遍历所有配置打印日志
        patterns.forEach((pattern, index) => {
            console.log(`配置[${index}]:`, pattern);
            console.log(`  - 快捷键:`, pattern.shortcut);
            console.log(`  - 小写比较:`, pattern.shortcut && pattern.shortcut.toLowerCase() === normalizedShortcut);
        });
        
        // 查找匹配的配置
        const matchingPattern = patterns.find(p => 
            p.shortcut && p.shortcut.toLowerCase() === normalizedShortcut
        );
        
        if (matchingPattern) {
            console.log('找到匹配的快捷键配置:', matchingPattern);
            return {
                found: true,
                pattern: matchingPattern,
                contentType: matchingPattern.contentType,
                customText: matchingPattern.customText
            };
        }
        
        console.log('未找到匹配的快捷键配置');
        return { found: false };
    } catch (error) {
        console.error('检查快捷键失败:', error);
        return { found: false, error: error.message };
    }
}

// 修改消息监听器
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
    // 不要立即响应，等待真正的处理结果
    if (!request || !request.action) {
        console.error('收到无效消息，缺少action字段');
        sendResponse({ error: '无效消息' });
        return false; // 没有异步操作，不需要保持通道开放
    }
    
    console.log('收到消息:', request.action);
    
    switch (request.action) {
        case 'ping':
            // 简单的ping响应
            console.log('处理ping请求');
            sendResponse({ status: 'ok' });
            return false; // 简单同步响应，不需要保持通道开放
            
        case 'handleKeyboardShortcut':
            // 处理键盘快捷键的消息，获取HTTPOnly cookies
            console.log('处理键盘快捷键请求:', request.shortcut);
            
            // 复用右键菜单获取HTTPOnly cookie的逻辑
            if (!sender || !sender.tab) {
                console.error('无法处理快捷键，缺少tab信息');
                sendResponse({ error: '缺少tab信息' });
                return false;
            }
            
            // 从请求中获取配置信息
            const patternConfig = request.pattern;
            if (!patternConfig) {
                console.error('无法处理快捷键，缺少pattern配置');
                sendResponse({ error: '缺少pattern配置' });
                return false;
            }
            
            // 生成请求ID
            const requestId = `${sender.tab.id}-${Date.now()}`;
            
            // 如果需要cookies，获取包括HTTPOnly的cookies
            if (patternConfig.contentType === 'cookies') {
                console.log('快捷键需要cookies，获取HTTPOnly cookies');
                
                // 获取所有cookies，包括HTTPOnly
                getAllCookies(sender.tab).then(allCookies => {
                    console.log(`获取到${allCookies.length}个cookie（包括HTTPOnly）`);
                    
                    // 发送消息到content script，包含所有cookie
                    chrome.tabs.sendMessage(sender.tab.id, {
                        action: 'handleShortcut',
                        pattern: patternConfig,
                        contentType: patternConfig.contentType || 'cookies',
                        customText: patternConfig.customText || '',
                        allCookies: allCookies,
                        requestId: requestId
                    }, response => {
                        if (chrome.runtime.lastError) {
                            console.error('发送消息失败:', chrome.runtime.lastError);
                            try {
                                sendResponse({ error: chrome.runtime.lastError.message });
                            } catch(error) {
                                console.error('发送响应失败，可能通道已关闭:', error);
                            }
                        } else {
                            console.log('快捷键处理消息发送成功');
                            try {
                                sendResponse({ success: true });
                            } catch(error) {
                                console.error('发送响应失败，可能通道已关闭:', error);
                            }
                        }
                    });
                }).catch(error => {
                    console.error('获取HTTPOnly cookie失败:', error);
                    // 即使获取HTTPOnly cookie失败，仍然发送消息
                    chrome.tabs.sendMessage(sender.tab.id, {
                        action: 'handleShortcut',
                        pattern: patternConfig,
                        contentType: patternConfig.contentType || 'cookies',
                        customText: patternConfig.customText || '',
                        requestId: requestId
                    });
                    try {
                        sendResponse({ warning: '获取HTTPOnly cookie失败，但已发送普通cookie' });
                    } catch(error) {
                        console.error('发送响应失败，可能通道已关闭:', error);
                    }
                });
                
                // 返回true保持消息通道开放
                return true;
            } else {
                // 不需要cookie，直接转发请求
                chrome.tabs.sendMessage(sender.tab.id, {
                    action: 'handleShortcut',
                    pattern: patternConfig,
                    contentType: patternConfig.contentType || 'custom',
                    customText: patternConfig.customText || '',
                    requestId: requestId
                }, response => {
                    if (chrome.runtime.lastError) {
                        console.error('发送消息失败:', chrome.runtime.lastError);
                        try {
                            sendResponse({ error: chrome.runtime.lastError.message });
                        } catch(error) {
                            console.error('发送响应失败，可能通道已关闭:', error);
                        }
                    } else {
                        console.log('快捷键处理消息发送成功');
                        try {
                            sendResponse({ success: true });
                        } catch(error) {
                            console.error('发送响应失败，可能通道已关闭:', error);
                        }
                    }
                });
                
                // 返回true保持消息通道开放
                return true;
            }
            
        case 'checkShortcut':
            console.log('处理checkShortcut请求:', request.shortcut);
            // 直接处理，不要使用异步
            chrome.storage.sync.get(['urlPatterns'], (result) => {
                const patterns = result.urlPatterns || [];
                console.log('获取到urlPatterns配置:', patterns);
                
                // 将输入的快捷键转换为小写进行比较
                const normalizedShortcut = request.shortcut.toLowerCase();
                
                // 遍历所有配置打印日志
                patterns.forEach((pattern, index) => {
                    console.log(`配置[${index}]:`, pattern);
                    console.log(`  - 快捷键:`, pattern.shortcut);
                    console.log(`  - 小写比较:`, pattern.shortcut && pattern.shortcut.toLowerCase() === normalizedShortcut);
                });
                
                // 查找匹配的配置
                const matchingPattern = patterns.find(p => 
                    p.shortcut && p.shortcut.toLowerCase() === normalizedShortcut
                );
                
                if (matchingPattern) {
                    console.log('找到匹配的快捷键配置:', matchingPattern);
                    try {
                        sendResponse({
                            found: true,
                            pattern: matchingPattern
                        });
                    } catch(error) {
                        console.error('发送响应失败，可能通道已关闭:', error);
                    }
                } else {
                    console.log('未找到匹配的快捷键配置');
                    try {
                        sendResponse({ found: false });
                    } catch(error) {
                        console.error('发送响应失败，可能通道已关闭:', error);
                    }
                }
            });
            // 返回true表示会异步调用sendResponse
            return true;
            
        case 'sendDataToBackend':
            if (!request.url) {
                console.error('发送数据失败: 缺少URL');
                sendResponse({ error: '缺少URL' });
                return false;
            }
            
            // 准备发送数据到内容脚本
            console.log('收到发送数据请求，准备传递给内容脚本:', request.url);
            
            // 确保在标签页中处理
            if (sender && sender.tab && sender.tab.id) {
                // 获取原始数据内容
                let rawData = '';
                if (request.data.customText) {
                    rawData = request.data.customText;
                } else if (request.data.pageContent) {
                    rawData = request.data.pageContent;
                } else if (request.data.cookies) {
                    rawData = request.data.cookies;
                }
                
                console.log('原始数据长度:', rawData ? rawData.length : 0);
                
                // 发送消息到内容脚本，请求其直接发送数据
                chrome.tabs.sendMessage(sender.tab.id, {
                    action: 'directSendRequest',
                    url: request.url,
                    data: rawData,
                    requestId: request.requestId
                }, response => {
                    if (chrome.runtime.lastError) {
                        console.error('发送directSendRequest消息失败:', chrome.runtime.lastError);
                    } else {
                        console.log('directSendRequest消息已发送，等待内容脚本处理');
                    }
                });
                
                // 立即响应，表示已收到请求
                sendResponse({ received: true, processing: true, timestamp: Date.now() });
            } else {
                console.error('无法确定发送方标签页');
                sendResponse({ error: '无法确定发送方标签页' });
            }
            
            return false;
            
        default:
            console.warn('未知的消息类型:', request.action);
            sendResponse({ error: '未知的消息类型' });
            return false;
    }
});

// 监听键盘命令
chrome.commands.onCommand.addListener(async (command) => {
    try {
        // 获取当前活动标签页
        const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
        if (!tab) {
            console.error('未找到活动标签页');
            return;
        }

        // 从存储中获取URL模式配置
        const result = await chrome.storage.sync.get(['urlPatterns']);
        const patterns = result.urlPatterns || [];
        
        // 查找匹配的快捷键配置
        const matchingPattern = patterns.find(p => p.shortcut === command);
        if (!matchingPattern) {
            console.log('未找到匹配的快捷键配置:', command);
            return;
        }

        // 检查URL是否匹配
        const url = new URL(tab.url);
        const pattern = matchingPattern.pattern;
        const isMatch = url.hostname.includes(pattern) || url.pathname.includes(pattern);
        
        if (!isMatch) {
            console.log('当前页面URL不匹配配置的URL模式');
            return;
        }

        // 如果需要获取cookie，先获取所有cookie
        if (matchingPattern.contentType === 'cookies') {
            console.log('需要获取cookie，包括HTTPOnly');
            getAllCookies(tab).then(allCookies => {
                // 发送消息到content script，包含所有cookie
                chrome.tabs.sendMessage(tab.id, {
                    action: 'handleShortcut',
                    pattern: matchingPattern,
                    contentType: matchingPattern.contentType || 'cookies',
                    customText: matchingPattern.customText || '',
                    allCookies: allCookies
                }, (response) => {
                    if (chrome.runtime.lastError) {
                        console.error('发送消息到content script失败:', chrome.runtime.lastError);
                    } else {
                        console.log('快捷键处理成功:', response);
                    }
                });
            }).catch(error => {
                console.error('获取cookie失败:', error);
                // 即使获取HTTPOnly cookie失败，仍然发送消息
                chrome.tabs.sendMessage(tab.id, {
                    action: 'handleShortcut',
                    pattern: matchingPattern,
                    contentType: matchingPattern.contentType || 'cookies',
                    customText: matchingPattern.customText || ''
                });
            });
        } else {
            // 不需要cookie，直接发送消息
            chrome.tabs.sendMessage(tab.id, {
                action: 'handleShortcut',
                pattern: matchingPattern,
                contentType: matchingPattern.contentType || 'cookies',
                customText: matchingPattern.customText || ''
            }, (response) => {
                if (chrome.runtime.lastError) {
                    console.error('发送消息到content script失败:', chrome.runtime.lastError);
                } else {
                    console.log('快捷键处理成功:', response);
                }
            });
        }
    } catch (error) {
        console.error('快捷键处理失败:', error);
    }
});

// 添加网络请求处理函数
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
  console.log('background.js收到消息:', request);
  
  // 处理发送数据到后端的请求
  if (request.action === 'sendDataToBackend') {
    // 立即发送确认消息
    console.log('后台收到数据发送请求，ID:', request.requestId);
    try {
      // 确保立即响应
      sendResponse({ received: true, processing: true, timestamp: Date.now() });
    } catch (error) {
      console.error('发送响应失败:', error);
    }
    
    // 确保URL是有效的，如果没有http前缀，添加它
    let url = request.url;
    if (!url.startsWith('http://') && !url.startsWith('https://')) {
      url = 'http://' + url;
    }
    
    // 获取要发送的原始数据内容
    let rawData = '';
    if (request.data.customText) {
      // 如果是自定义文本，直接使用
      rawData = request.data.customText;
    } else if (request.data.pageContent) {
      // 如果是页面内容，直接使用
      rawData = request.data.pageContent;
    } else if (request.data.cookies) {
      // 如果是cookie信息，转为字符串
      rawData = request.data.cookies;
    } else {
      // 默认情况下使用空字符串
      rawData = '';
    }
    
    // 设置请求ID防止重复发送
    const requestId = Date.now().toString();
    
    // 使用全局变量而非window
    if (typeof _pendingRequests === 'undefined') {
      globalThis._pendingRequests = {};
    }
    
    // 如果当前有相同URL的请求正在进行，则不重复发送
    if (_pendingRequests[url]) {
      console.log('已有相同URL的请求正在处理中:', url);
      // 通知内容脚本
      if (sender && sender.tab && sender.tab.id) {
        chrome.tabs.sendMessage(sender.tab.id, {
          action: 'backendResponse',
          success: false,
          error: '已有相同请求正在处理中，请稍后再试',
          originalRequest: request
        });
      }
      
      return true;
    }
    
    // 记录此URL正在处理中
    _pendingRequests[url] = requestId;
    console.log('记录URL请求状态:', url, requestId);
    
    // 设置保底超时清理，避免请求状态永远不清除
    setTimeout(() => {
      if (_pendingRequests && _pendingRequests[url] === requestId) {
        delete _pendingRequests[url];
        console.log('超时自动清理请求状态:', url);
      }
    }, 30000); // 30秒超时自动清理
    
    console.log('开始发送POST请求到:', url);
    
    // 尝试多种方式获取Referer
    const referer = request.referer || request.refererUrl || request.originUrl || (sender && sender.tab ? sender.tab.url : '');
    console.log('后台收到的Referer:', referer);
    
    // 始终使用content script发送请求，这样会自动包含当前页面URL作为Referer
    if (sender && sender.tab && sender.tab.id) {
      console.log('将通过content script发送请求，以确保Referer正确');
      
      // 在等待响应之前先记录请求状态
      const requestTimeoutId = setTimeout(() => {
        if (_pendingRequests && _pendingRequests[url] === requestId) {
          delete _pendingRequests[url];
          console.log('请求超时，清除状态:', url);
          
          // 通知内容脚本请求超时
          try {
            chrome.tabs.sendMessage(sender.tab.id, {
              action: 'backendResponse',
              success: false,
              error: '请求超时',
              originalRequest: request,
              timestamp: Date.now()
            });
          } catch (error) {
            console.error('发送超时通知失败:', error);
          }
        }
      }, 30000); // 30秒超时
      
      // 添加一个监听器来处理directSendRequest的结果
      const directSendResultListener = function(message) {
        if (message.action === 'directSendRequestResult' && message.requestId === requestId) {
          // 收到结果，移除监听器
          chrome.runtime.onMessage.removeListener(directSendResultListener);
          
          // 清除超时计时器
          clearTimeout(requestTimeoutId);
          
          // 清除请求状态
          if (_pendingRequests && _pendingRequests[url] === requestId) {
            delete _pendingRequests[url];
            console.log('请求完成，清除状态:', url);
          }
          
          // 处理结果
          if (message.success) {
            console.log('请求成功，状态码:', message.status);
            
            // 转发成功响应给原内容脚本
            try {
              chrome.tabs.sendMessage(sender.tab.id, {
                action: 'backendResponse',
                success: true,
                data: { 
                  status: 'success', 
                  responseStatus: message.status,
                  text: message.text
                },
                originalRequest: request,
                timestamp: Date.now()
              });
            } catch (error) {
              console.error('发送成功响应失败:', error);
            }
          } else {
            console.error('请求失败:', message.error);
            
            // 转发失败响应给原内容脚本
            try {
              chrome.tabs.sendMessage(sender.tab.id, {
                action: 'backendResponse',
                success: false,
                error: message.error,
                originalRequest: request,
                timestamp: Date.now()
              });
            } catch (error) {
              console.error('发送失败响应失败:', error);
            }
          }
        }
      };
      
      // 添加临时监听器
      chrome.runtime.onMessage.addListener(directSendResultListener);
      
      // 向content script发送请求
      chrome.tabs.sendMessage(sender.tab.id, {
        action: 'directSendRequest',
        url: url,
        data: rawData,
        requestId: requestId
      }, response => {
        if (chrome.runtime.lastError) {
          console.error('发送directSendRequest消息失败:', chrome.runtime.lastError);
          
          // 清除超时计时器
          clearTimeout(requestTimeoutId);
          
          // 移除监听器
          chrome.runtime.onMessage.removeListener(directSendResultListener);
          
          // 清除请求状态
          if (_pendingRequests && _pendingRequests[url] === requestId) {
            delete _pendingRequests[url];
            console.log('请求错误，清除状态:', url);
          }
          
          // 通知内容脚本错误
          try {
            chrome.tabs.sendMessage(sender.tab.id, {
              action: 'backendResponse',
              success: false,
              error: chrome.runtime.lastError.message,
              originalRequest: request,
              timestamp: Date.now()
            });
          } catch (error) {
            console.error('发送错误响应失败:', error);
          }
        } else {
          console.log('directSendRequest消息已发送，等待结果...');
        }
      });
      
      // 返回成功发送请求的响应
      return { success: true, message: '请求已转发至内容脚本' };
    } else {
      console.warn('无法使用content script发送请求，无有效标签页');
      return { error: '无有效标签页，无法发送请求' };
    }
  }
}); 